//Panel meter OLED version 2021

#include "msp430G2553.h"
#include "math.h"

//============ Define preset values here
#define firmware_version 1.1   //            This will show up on the screen at startup
#define hardware_version 3.1   //            This will show up on the code - The first char means A,B or C versions
#define over_current_value 9.9 // [A]  (5.0) more than this current on the meter will trigger the error
#define over_voltage_value 29.9// [V]        exceeding this input voltage will trigger the error


//=========== Define general values here
#define Clear        0x00  // LCD bits and commands definition
#define SDA          BIT0
#define SCL          BIT1
#define SLAVE_ADDR   0x78
#define COMMAND_STR  0x00
#define COMMA_SINGLE 0x80
#define DATA_STR     0x40
#define DISP_OFF     0xAE
#define DISP_ON      0xAF
#define SETCOL_ADR   0x21
#define SETPAGE_ADR  0x22
#define SETSTARTLINE 0x40
#define SETCONTRAST  0x81
#define MEMORYMODE   0x20
#define SETMULTIPLEX 0xA8
#define DISP_OFFSET  0xD3
#define CHARGE_PUMP  0x8D
#define DISP_CK_DIV  0x5D
#define PRE_CHARGE   0xD9
#define VCOMH_DESEL  0xDB
#define NORMAL_DISP  0xA6
#define INVERT_DISP  0xA7
#define NORMAL_X     0xA1
#define FLIPED_X     0xA0
#define NORMAL_Y     0xC8
#define FLIPED_Y     0xC0


#define ERR_OC BIT0  // Over current error. Taking too much current or short circuit.
#define ERR_OV BIT1  // Over voltage error. Signifies that the input voltage is above the safe limit. 
 
int array_div_mod[4];
float medc[10],medv[10];

const unsigned char bck_ground_logo1[32] = {' ',' ','P','a','n','e','l',' ',' ',' ','M','e','t','e','r',' ',' ','M','a','r','i','u','s',' ',' ','T','a','c','i','u','c',' '};
const unsigned char bck_ground_subsolder[16] = {' ',' ',' ','.',' ',' ',' ','V'};
const unsigned char err_over_current[8] = {'O','v','r',' ','c','u','r','r'};
const unsigned char err_over_volt[8] = {'O','v','r',' ','v','o','l','t'};
const unsigned char errors_multiple[8] = {' ','E','r','r','o','r','s',' '};

const unsigned char mask[8] = {0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};
const unsigned char ascii_chart[640] = {
/*00-000- */0x80,0x40,0x28,0x1C,0x3E,
/*01-001- */0x0F,0x07,0x01,0x02,0x1C,
/*02-002- */0x82,0x66,0xAF,0xE6,0x82,
/*03-003- */0x78,0x24,0x22,0x24,0x78,
/*04-004- */0x78,0x24,0x22,0x24,0x78,
/*05-005- */0x78,0x24,0x22,0x24,0x78,
/*06-006- */0x78,0x24,0x22,0x24,0x78,
/*07-007- */0x78,0x24,0x22,0x24,0x78,
/*08-008- */0x78,0x24,0x22,0x24,0x78,
/*09-009- */0x78,0x24,0x22,0x24,0x78,
/*0A-010- */0x78,0x24,0x22,0x24,0x78,
/*0B-011- */0x78,0x24,0x22,0x24,0x78,
/*0C-012- */0x78,0x24,0x22,0x24,0x78,
/*0D-013- */0x78,0x24,0x22,0x24,0x78,
/*0E-014- */0x78,0x24,0x22,0x24,0x78,
/*0F-015- */0x78,0x24,0x22,0x24,0x78,
/*10-016- */0x78,0x24,0x22,0x24,0x78,
/*11-017- */0x78,0x24,0x22,0x24,0x78,
/*12-018- */0x78,0x24,0x22,0x24,0x78,
/*13-019- */0x78,0x24,0x22,0x24,0x78,
/*14-020- */0x78,0x24,0x22,0x24,0x78,
/*15-021- */0x78,0x24,0x22,0x24,0x78,
/*16-022- */0x78,0x24,0x22,0x24,0x78,
/*17-023- */0x78,0x24,0x22,0x24,0x78,
/*18-024- */0x78,0x24,0x22,0x24,0x78,
/*19-025- */0x78,0x24,0x22,0x24,0x78,
/*1A-026- */0x78,0x24,0x22,0x24,0x78,
/*1B-027- */0x78,0x24,0x22,0x24,0x78,
/*1C-028- */0x78,0x24,0x22,0x24,0x78,
/*1D-029- */0x78,0x24,0x22,0x24,0x78,
/*1E-030- */0x78,0x24,0x22,0x24,0x78,
/*1F-031- */0x78,0x24,0x22,0x24,0x78,
/*20-032- */0x00,0x00,0x00,0x00,0x00,
/*21-033- */0x78,0x24,0x22,0x24,0x78,
/*22-034- */0x78,0x24,0x22,0x24,0x78,
/*23-035- */0x78,0x24,0x22,0x24,0x78,
/*24-036- */0x78,0x24,0x22,0x24,0x78,
/*25-037-%*/0x23,0x13,0x08,0x64,0x62,
/*26-038- */0x78,0x24,0x22,0x24,0x78,
/*27-039- */0x78,0x24,0x22,0x24,0x78,
/*28-040- */0x78,0x24,0x22,0x24,0x78,
/*29-041- */0x78,0x24,0x22,0x24,0x78,
/*2A-042-**/0x00,0x06,0x09,0x09,0x06,
/*2B-043-+*/0x08,0x08,0x3E,0x08,0x08,
/*2C-044-,*/0x78,0x24,0x22,0x24,0x78,
/*2D-045--*/0x08,0x08,0x08,0x08,0x08,
/*2E-046-.*/0x00,0x60,0x60,0x00,0x00,
/*2F-047- */0x78,0x24,0x22,0x24,0x78,
/*30-048-0*/0x3E,0x51,0x49,0x45,0x3E,
/*31-049-1*/0x00,0x42,0x7F,0x40,0x00,
/*32-050-2*/0x42,0x61,0x51,0x49,0x46,
/*33-051-3*/0x21,0x41,0x45,0x4B,0x31,
/*34-052-4*/0x18,0x14,0x12,0x7F,0x10,
/*35-053-5*/0x27,0x45,0x45,0x45,0x39,
/*36-054-6*/0x3C,0x4A,0x49,0x49,0x30,
/*37-055-7*/0x03,0x01,0x71,0x09,0x07,
/*38-056-8*/0x36,0x49,0x49,0x49,0x36,
/*39-057-9*/0x06,0x49,0x49,0x29,0x1E,
/*3A-058- */0x78,0x24,0x22,0x24,0x78,
/*3B-059- */0x78,0x24,0x22,0x24,0x78,
/*3C-060-<*/0x64,0xCE,0x9F,0x84,0x78,
/*3D-061-=*/0x14,0x14,0x14,0x14,0x14,
/*3E-062->*/0x78,0x84,0x9F,0xCE,0x64,
/*3F-063- */0x78,0x24,0x9F,0xCE,0x64,
/*40-064- */0x78,0x24,0x22,0x24,0x78,
/*41-065-A*/0x7C,0x1E,0x11,0x12,0x7C,
/*42-066-B*/0x7F,0x79,0x49,0x49,0x36,
/*43-067-C*/0x3E,0x7F,0x41,0x41,0x22,
/*44-068-D*/0x7F,0x7F,0x41,0x41,0x3E,
/*45-069-E*/0x7F,0x7F,0x49,0x49,0x41,
/*46-070-F*/0x7F,0x7F,0x09,0x09,0x01,
/*47-071-G*/0x3E,0x7F,0x41,0x51,0x72,
/*48-072-H*/0x7F,0x7F,0x08,0x08,0x7F,
/*49-073-I*/0x00,0x41,0x7F,0x41,0x00,
/*4A-074-J*/0x20,0x41,0x41,0x3F,0x01,
/*4B-075-K*/0x7F,0x1C,0x36,0x63,0x41,
/*4C-076-L*/0x7F,0x7F,0x40,0x40,0x40,
/*4D-077-M*/0x7F,0x02,0x0C,0x02,0x7F,
/*4E-078-N*/0x7F,0x06,0x0C,0x18,0x7F,
/*4F-079-O*/0x3E,0x7F,0x41,0x41,0x3E,
/*50-080-P*/0x7F,0x0F,0x09,0x09,0x06,
/*51-081-Q*/0x3E,0x7F,0x51,0x21,0x5E,
/*52-082-R*/0x7F,0x0F,0x19,0x29,0x46,
/*53-083-S*/0x46,0x4F,0x49,0x79,0x31,
/*54-084-T*/0x01,0x01,0x7F,0x01,0x01,
/*55-085-U*/0x3F,0x7F,0x40,0x40,0x3F,
/*56-086-V*/0x1F,0x20,0x60,0x20,0x1F,
/*57-087-W*/0x3F,0x40,0x38,0x40,0x3F,
/*58-088-X*/0x63,0x14,0x08,0x14,0x63,
/*59-089-Y*/0x07,0x08,0x70,0x08,0x07,
/*5A-090-Z*/0x61,0x71,0x49,0x45,0x43,
/*5B-091- */0x78,0x24,0x22,0x24,0x78,
/*5C-092- */0x78,0x24,0x22,0x24,0x78,
/*5D-093- */0x78,0x24,0x22,0x24,0x78,
/*5E-094- */0x78,0x24,0x22,0x24,0x78,
/*5F-095- */0x78,0x24,0x22,0x24,0x78,
/*60-096- */0x78,0x24,0x22,0x24,0x78,
/*61-097-a*/0x20,0x54,0x54,0x54,0x78,
/*62-098-b*/0x7F,0x48,0x44,0x44,0x38,
/*63-099-c*/0x38,0x44,0x44,0x44,0x20,
/*64-100-d*/0x38,0x44,0x44,0x48,0x3F,
/*65-101-e*/0x38,0x54,0x54,0x54,0x18,
/*66-102-f*/0x08,0x7E,0x09,0x01,0x02,
/*67-103-g*/0x0C,0x52,0x52,0x52,0x2E,
/*68-104-h*/0x7F,0x08,0x04,0x04,0x78,
/*69-105-i*/0x00,0x44,0x7D,0x40,0x00,
/*6A-106-j*/0x20,0x40,0x44,0x3D,0x00,
/*6B-107-k*/0x7F,0x10,0x28,0x44,0x00,
/*6C-108-l*/0x00,0x41,0x7F,0x40,0x00,
/*6D-109-m*/0x7C,0x04,0x18,0x04,0x78,
/*6E-110-n*/0x7C,0x08,0x04,0x04,0x78,
/*6F-111-o*/0x38,0x44,0x44,0x44,0x38,
/*70-112-p*/0x7C,0x14,0x14,0x14,0x08,
/*71-113-q*/0x08,0x14,0x14,0x18,0x7C,
/*72-114-r*/0x7C,0x08,0x04,0x04,0x08,
/*73-115-s*/0x48,0x54,0x54,0x54,0x20,
/*74-116-t*/0x04,0x3F,0x44,0x40,0x20,
/*75-117-u*/0x3C,0x40,0x40,0x20,0x7C,
/*76-118-v*/0x1C,0x20,0x40,0x20,0x1C,
/*77-119-w*/0x3C,0x40,0x38,0x40,0x3C,
/*78-120-x*/0x44,0x28,0x10,0x28,0x44,
/*79-121-y*/0x0C,0x50,0x50,0x50,0x3C,
/*7A-122-z*/0x44,0x64,0x54,0x4C,0x44,
/*7B-123- */0x78,0x24,0x22,0x24,0x78,
/*7C-124- */0x78,0x24,0x22,0x24,0x78,
/*7D-125- */0x78,0x24,0x22,0x24,0x78,
/*7E-126- */0x78,0x24,0x22,0x24,0x78,
/*7F-127- */0x78,0x24,0x22,0x24,0x78,
};
const unsigned char large_number_chart[220] = {
/*01-000-0*/0xFC,0x06,0x03,0x01,0x01,
/*02-000-0*/0x01,0x01,0x03,0xFE,0xFC,
/*03-000-0*/0x1F,0x20,0x40,0x40,0x40,
/*04-000-0*/0x40,0x40,0x60,0x3F,0x1F,
/*01-000-1*/0x20,0x30,0x18,0x0C,0x06,
/*02-000-1*/0xFF,0xFF,0x00,0x00,0x00,
/*03-000-1*/0x40,0x60,0x60,0x60,0x60,
/*04-000-1*/0x7F,0x7F,0x60,0x60,0x70,
/*01-000-2*/0x30,0x3C,0x06,0x03,0x01,
/*02-000-2*/0x01,0x81,0xC3,0x66,0x3C,
/*03-000-2*/0x60,0x70,0x78,0x6C,0x66,
/*04-000-2*/0x63,0x61,0x60,0x60,0x70,
/*01-000-3*/0x07,0x03,0x03,0x03,0xC3,
/*02-000-3*/0xC3,0x63,0x13,0x0B,0x07,
/*03-000-3*/0x30,0x60,0x60,0x60,0x60,
/*04-000-3*/0x60,0x61,0x61,0x33,0x1E,
/*01-000-4*/0xC0,0xF0,0x3C,0x0F,0x03,
/*02-000-4*/0x00,0xE0,0x00,0x00,0x00,
/*03-000-4*/0x03,0x03,0x03,0x03,0x03,
/*04-000-4*/0x03,0x7F,0x03,0x03,0x03,
/*01-000-5*/0xFF,0xC3,0x63,0x63,0x63,
/*02-000-5*/0x63,0x63,0xE3,0xC3,0x87,
/*03-000-5*/0x30,0x30,0x40,0x40,0x40,
/*04-000-5*/0x40,0x40,0x60,0x3F,0x1F,
/*01-000-6*/0xF0,0xF8,0x6C,0x66,0x63,
/*02-000-6*/0x61,0x61,0xE0,0xC0,0x80,
/*03-000-6*/0x1F,0x20,0x40,0x40,0x40,
/*04-000-6*/0x40,0x40,0x60,0x3F,0x1F,
/*01-000-7*/0x07,0x03,0x03,0x03,0x03,
/*02-000-7*/0x83,0xE3,0x7B,0x1F,0x07,
/*03-000-7*/0x00,0x00,0x01,0x79,0x7F,
/*04-000-7*/0x07,0x01,0x01,0x00,0x00,
/*01-000-8*/0x80,0xCE,0x5B,0x71,0x61,
/*02-000-8*/0x61,0x61,0xFF,0xCE,0x80,
/*03-000-8*/0x1F,0x20,0x40,0x40,0x40,
/*04-000-8*/0x40,0x40,0x60,0x3F,0x1F,
/*01-000-9*/0xFC,0x86,0x03,0x01,0x01,
/*02-000-9*/0x01,0x01,0x83,0xFE,0xFC,
/*03-000-9*/0x00,0x01,0x01,0x01,0x61,
/*04-000-9*/0x79,0x1F,0x07,0x01,0x00,
/*01-000-|*/0x7C,0xC7,0x00,0x78,0x1F,
/*02-000-|*/0x00,0xA0,0xF0,0xF8,0xFC,
/*03-000-|*/0x40,0x31,0x38,0x1C,0x0E,
/*04-000-|*/0x07,0x03,0x21,0x70,0x21
};

const unsigned char Init[27] = {
  0x00,
  DISP_OFF,
  COMMAND_STR,
  SETCONTRAST,0x7F,
  MEMORYMODE,0x00,
  0xB0,0x00,0x10,
  FLIPED_X,
  FLIPED_Y,
  SETMULTIPLEX,0x3F,
  DISP_OFFSET,0x00,
  CHARGE_PUMP,0x14,
  DISP_CK_DIV,0x80,
  PRE_CHARGE,0x22,
  VCOMH_DESEL,0x20,
  NORMAL_DISP,
  SETSTARTLINE,
  DISP_ON};


unsigned char match,match_low,err,txt,half;
int temp2,i,n,tenthsp,unitsp,decimal1p,tenthsv,unitsv,decimal1v,decimal2v,menu;
int tenthsc,unitsc,decimal1c,decimal2c,decimal3c;
int menumem,menu_ps,buton,rotE,PWM_test;
int IntVolt,IntCur,count_m; 
float volt_val_c,cur_val_c,volt_val,cur_val,m,d_power;
int j,k,l,byte,a,c,x,y;

float convert_volt(float);
float convert_cur(float);
float convert_btemp(float);
float convert_ttemp(float);
float bucla_div_mod(float);

void ADC_sampling(int);
void ADC_convert(int);
void ADC_average(int);
void ADC_div_mod(int);
void move_cursor_xy(int,int);
void display_char(unsigned char); 
void delay_time(int);
void delay_long(int);
void delay_extra_long(int);
void cls(int);
void draw_Logo(int);
void draw_sub_menu(int);
void init_scr(int);
void start_condition(int);
void stop_condition(int);
void display_char(unsigned char);
void dispbig_char(unsigned char);
void large_number_print(unsigned char);
void number_print(unsigned char);
void ack_bit(int);

int byte_transmit(int);
int byte_expandH(int);
int byte_expandH(int);





void main(void){
WDTCTL = WDTPW + WDTHOLD; // disable watch dog timer
DCOCTL = CALDCO_16MHZ; // set internal oscillator at 16MHz
BCSCTL1 = CALBC1_16MHZ; // set internal oscillator at 16MHz

P1OUT = Clear;
P2OUT = 0xFF;
P3OUT = Clear;
P1DIR = 0x83; // 1000 0011
P2DIR = 0xFF; // 1111 1111
P3DIR = 0xF8; // 1111 1000
delay_extra_long(0);

//--------------------config ADC
ADC10CTL1 |= INCH_2; //continuous sample mode, CH2 // CONSEQ1 + INCH_2
ADC10CTL0 |= ADC10SHT_2 + ADC10ON + MSC; //sample and hold time, adc on, cont. sample
ADC10AE0 |= 0x04; // select channel A2
ADC10CTL0 |= ADC10SC + ENC; // start conversions

err = 0;
menu = 1;


init_scr(0);
cls(0);
delay_time(5000);
cls(0);
draw_Logo(0);


for(n=0;n<6;n++){
ADC_sampling(0);
ADC_convert(0);
ADC_average(0);
}    
ADC_div_mod(0);

        for(;;) {            
                 
                  
        if(menu == 1){           //=========================================== Meter menu 1 =========================
               
        draw_sub_menu(0);   
        m = firmware_version;    
        m = m/10;
        bucla_div_mod(m); 
        move_cursor_xy(2,0);      //---display Firmware version shortly
        large_number_print(array_div_mod[1]);
        large_number_print(array_div_mod[2]);
        dispbig_char(' ');
        large_number_print(array_div_mod[3]);   
        delay_extra_long(0); 
        match = 0;
        do{  
  
                if(PWM_test == 0){
                 PWM_test = 1;
                 n = 36;   //30
                }
                else{
                 PWM_test = 0;
                 n = 12;   //10
                }
          
                         //------------------------------------------  Reading loop
                do{									
    	    	
                ADC_sampling(0);
                ADC_convert(0);
                ADC_average(0);
          
//---------------------------------------------  check for errors

          if(cur_val > over_current_value){
          err |= ERR_OC;
          delay_time(1000);
          }
          else{
          err &= ~(ERR_OC);
          }
          
          if(volt_val > over_voltage_value){
          err |= ERR_OV;
          delay_time(1000);
          }
          else{
          err &= ~(ERR_OV);
          }
           
                  n--;
                  }while (n != 0);    //----------------------------  End of reading loop
             
          ADC_div_mod(0);
       
//------------------------------------------------------ display values   

        move_cursor_xy(2,0);
        large_number_print(tenthsv);                
        large_number_print(unitsv);
        dispbig_char(' ');
        large_number_print(decimal1v); 
        large_number_print(decimal2v);

        if(err > 0){
          move_cursor_xy(7,6); 
          if(err == 1){  
          for(i=0;i<8;i++){
          dispbig_char(err_over_current[i]);
          } 
          }
          
          if(err == 2){       
          for(i=0;i<8;i++){
          dispbig_char(err_over_volt[i]);
          } 
          }
          
          if(err == 3){
          move_cursor_xy(7,6);        
          for(i=0;i<8;i++){
          dispbig_char(errors_multiple[i]);
          }   
          }
        }
        else{
        move_cursor_xy(0,6);
        number_print(unitsc);
        dispbig_char('.');
        number_print(decimal1c);
        dispbig_char('A');
        dispbig_char(' ');
        number_print(tenthsp);
        number_print(unitsp);
        number_print(decimal1p);        
        dispbig_char('W');
        }       

                
 
                    }while (1) ;               
             }   // ==================================================================== Meter menu 1 END ==========      
}                                    
}




//---------------------------------------------------------------------------------------------------------------------------------------
//-----------------  FUNCTIONS  -----------  PROCEDURES  -----------  FUNCTIONS  -----------  PROCEDURES  -----------  FUNCTIONS  -------
//---------------------------------------------------------------------------------------------------------------------------------------

void start_condition(int){   // -------------------------------------- I2C start condition ---------
    P2OUT &= ~(SDA);       
    delay_time(10); 
    P2OUT &= ~(SCL);              
    delay_time(40);  
    byte_transmit(SLAVE_ADDR);
}



void stop_condition(int){    // --------------------------------------- I2C stop condition ---------
    P2OUT |= SCL;       
    delay_time(10); 
    P2OUT |= SDA;             
    delay_time(40); 
}



void ack_bit(int){           // ------------------------------------------ ACK bit ----------------
    P2DIR = 0xFE;            // 1111 1110     
    P2OUT |= SCL;
    delay_time(10); 
    P2OUT &= ~(SCL);  
    P2DIR = 0xFF; 
}



int byte_transmit(int t_byte){  //  ------------------------Byte Transmit (transmit a single byte to I2C)--
  for(l=0;l<8;l++){      
    byte = t_byte; 
    if((byte &= mask[l]) > 0){
    P2OUT |= SDA;
    }
    else{
    P2OUT &= ~(SDA);
    }
    P2OUT |= SCL;
    delay_time(10); 
    P2OUT &= ~(SCL);
    P2OUT &= ~(SDA);
    delay_time(10);
  }  
    ack_bit(0); 
return (0);
}



int byte_expandH(int t_byte){  //  -----------------------------  Byte expand Higher half  -------
  for(l=4;l<8;l++){  
    for(j=0;j<2;j++){    
    byte = t_byte; 
    if((byte &= mask[l]) > 0){
    P2OUT |= SDA;
    }
    else{
    P2OUT &= ~(SDA);
    }
    P2OUT |= SCL;
    delay_time(10); 
    P2OUT &= ~(SCL);
    P2OUT &= ~(SDA);
    delay_time(10);
  }
  }  
    ack_bit(0); 
return (0);
}



int byte_expandL(int t_byte){  //  -------------------------------  Byte expand Lower half  -------
  for(l=0;l<4;l++){  
    for(j=0;j<2;j++){    
    byte = t_byte; 
    if((byte &= mask[l]) > 0){
    P2OUT |= SDA;
    }
    else{
    P2OUT &= ~(SDA);
    }
    P2OUT |= SCL;
    delay_time(10); 
    P2OUT &= ~(SCL);
    P2OUT &= ~(SDA);
    delay_time(10);
  }
  }  
    ack_bit(0); 
return (0);
}



void init_scr(int){              //-------------------------------------- Init Screen ---------------------  

  start_condition(0);
  for(c=0;c<27;c++){
  byte_transmit(Init[c]);   
  }  
    stop_condition(0);
}



void move_cursor_xy(int col, int row){   // -----------------------  Go to screen coordinates -------
int col_H, col_L;

  x = col;
  y = row;
  col_H = col;
  col_L = col;
  col_H = col_H >> 4;
  col_H &= ~(0xF0);
  col_L &= ~(0xF0);
  
  start_condition(0);
  byte_transmit(COMMAND_STR); 
  byte_transmit(MEMORYMODE);
  byte_transmit(0x00); 
  byte_transmit(0xB0 + row);
  byte_transmit(col_L);
  byte_transmit(col_H |= 0x10);
  stop_condition(0);
}



void cls(int){                   //-------------------------------------- Clear Screen ---------------------  
 
  start_condition(0);
  byte_transmit(DATA_STR);    //Command for data stream
  
  for(c=0;c<1024;c++){
  byte_transmit(0x00);  
  }  
    stop_condition(0);  
}



void display_char(unsigned char txt){ //--------------------------------  Display char -------------
  start_condition(0); 
  byte_transmit(DATA_STR);  //Command for data stream
  
  byte_transmit(0x00);      //blank column space
  for(c=0;c<5;c++){
  byte_transmit(ascii_chart[(txt*5) + c]); 
  } 
  byte_transmit(0x00);      //blank column space
  stop_condition(0);    
}



void dispbig_char(unsigned char txt){ //----------------------------  Display large char -------------
  start_condition(0);
  byte_transmit(DATA_STR);  //Command for data stream  
  
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  for(c=0;c<5;c++){
    for(k=0;k<2;k++){
    byte_expandH(ascii_chart[(txt*5) + c]); 
    }
  } 
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  stop_condition(0); 
 
  y++;
  move_cursor_xy(x,y); 
  start_condition(0); 
  byte_transmit(DATA_STR);  //Command for data stream  
  
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  for(c=0;c<5;c++){
    for(k=0;k<2;k++){
    byte_expandL(ascii_chart[(txt*5) + c]); 
    } 
  } 
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  stop_condition(0);  

  x = x+14; 
  y--;
  move_cursor_xy(x,y); 
}

void number_print(unsigned char txt){ //--------------------  Display a two line number -------------
  start_condition(0);
  byte_transmit(DATA_STR);  //Command for data stream  
  
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  for(c=0;c<10;c++){
    byte_transmit(large_number_chart[(txt*20) + c]);  
  } 
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  stop_condition(0); 
 
  y++;
  move_cursor_xy(x,y); 
  start_condition(0); 
  byte_transmit(DATA_STR);  //Command for data stream  
  
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  for(c=10;c<20;c++){
    byte_transmit(large_number_chart[(txt*20) + c]); 
  } 
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  stop_condition(0); 
  
  x = x+14; 
  y = y-1;
  move_cursor_xy(x,y); 
}



void large_number_print(unsigned char txt){ //--------------------  Display a large number -------------
  for(half=0;half<2;half++){
  start_condition(0);
  byte_transmit(DATA_STR);  //Command for data stream  
  
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  for(c=(10*half);c<(10*(half+1));c++){
    for(k=0;k<2;k++){
    byte_expandH(large_number_chart[(txt*20) + c]);  
    }
  } 
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  stop_condition(0); 
 
  y++;
  move_cursor_xy(x,y); 
  start_condition(0); 
  byte_transmit(DATA_STR);  //Command for data stream  
  
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  for(c=(10*half);c<(10*(half+1));c++){
    for(k=0;k<2;k++){
    byte_expandL(large_number_chart[(txt*20) + c]); 
    } 
  } 
  for(k=0;k<2;k++){
  byte_transmit(0x00);      //blank column space
  }
  stop_condition(0); 
  y++;
  move_cursor_xy(x,y);
  }

  x = x+24; 
  y = y-4;
  move_cursor_xy(x,y); 
}



void ADC_sampling(int){     //--------------------------------- Sample the ADC ports for values
  
                
//-------------------------------------------------read current
        ADC10CTL1 &= ~(INCH_6); //disable continuous sample mode,  CH7                
        ADC10CTL1 |= INCH_7; //continuous sample mode, CH6
        ADC10AE0 |= 0x80; // select channel A3 //0100 0000
        ADC10CTL0 |= ADC10SC + ENC; // start conversions    
        delay_time(50);
        IntCur = ADC10MEM; 
        ADC10CTL0 &= ~(ADC10SC + ENC); // stop conversions                
                
//-------------------------------------------------read voltage
        ADC10CTL1 &= ~(INCH_7); //disable continuous sample mode, CH6                         
        ADC10CTL1 |= INCH_6; //continuous sample mode, CH7
        ADC10AE0 |= 0x40; // select channel A7 //1000 0000
        ADC10CTL0 |= ADC10SC + ENC; // start conversions     
        delay_time(50);
        IntVolt = ADC10MEM; 
        ADC10CTL0 &= ~(ADC10SC + ENC); // stop conversions
}



void ADC_convert(int){     //---------------------------------- Convert the sampled values 
  
        volt_val_c = convert_volt (IntVolt);
        cur_val_c = convert_cur (IntCur);
        d_power = ((volt_val*cur_val)/10);
}



void ADC_average(int){     //----------------------------- Average last 5 samples for all measurements

        if (IntVolt > 0x00){
          for(i=0; i<9; i++){
          medv[i] = medv[i+1]; 
          medc[i] = medc[i+1];
          }
          medv[9] = volt_val_c; 
          medc[9] = cur_val_c;
        }
        volt_val = ((medv[0]+medv[1]+medv[2]+medv[3]+medv[4]+medv[5]+medv[6]+medv[7]+medv[8]+medv[9])/10);
        cur_val = ((medc[0]+medc[1]+medc[2]+medc[3]+medc[4]+medc[5]+medc[6]+medc[7]+medc[8]+medc[9])/10);
}



void ADC_div_mod(int){
  //------------------------------ Loop for div/mod       voltage Values  

        bucla_div_mod(volt_val);        
        tenthsv = array_div_mod[0];
        unitsv = array_div_mod[1];
        decimal1v = array_div_mod[2];
        decimal2v = array_div_mod[3];
      
//------------------------------ Loop for div/mod       Power Values  

        bucla_div_mod(d_power);
        tenthsp = array_div_mod[0];
        unitsp = array_div_mod[1]; 
        decimal1p = array_div_mod[2]; 
       
 //----------------------------- Loop for div/mod       Current Values  

        bucla_div_mod(cur_val);
        tenthsc = array_div_mod[0];
        unitsc = array_div_mod[1];
        decimal1c = array_div_mod[2]; 
        decimal2c = array_div_mod[3]; 
      
}



void delay_time (int delay){      //----------------------------------------- Delay---------------------      
	do delay--;
	while (delay != 0);
}



void delay_long (int){            //--------------------------------------- long Delay ------------------
        int j;                   
        j = 200;
    	do{	
        delay_time(5000);
    	j--;
    	}while (j != 0); 
}



void delay_extra_long (int){            //------------------------------extra long Delay ------------------
        count_m = 6;
        do{
        delay_long(0); 
        count_m --;
        }while(count_m !=0); 
}



float convert_volt (float IntVolt){         // ------------------------Voltage conversion
float voltage,ua2,raport_divizor,r2,r1;
        
        r1 = 9960;
        r2 = 1005;
	ua2 = (3.29/1024*IntVolt);
	raport_divizor = ((r1+r2)/r2);                                     
	voltage = ((ua2*raport_divizor) + 0.25); //0.25 means diode dropout - also constant for shifting function on y axis
   
return (float)(voltage);
}



float convert_cur (float IntCur){           // ------------------------Current conversion
float current,Usunt,factor_op_amp,r2_op,r1_op,rs;
        
        r1_op = 1000;
        r2_op = 10000;
        rs = 0.020;
	factor_op_amp = (1+(r2_op/r1_op));  
        Usunt = ((3.29/1024*IntCur)/factor_op_amp);
	current = ((Usunt/rs)-0.03);               // 0.03 is constant for shifting the function on y axis
      //  if (current < 0.1) { current = 0.01; }   // Low trim values
        
return (float)(current);
}





float bucla_div_mod(float ref_temp_val){   //---------------------------- Loop for div/mod ------------
unsigned char j;
  
for(i=0; i<4; i++){
array_div_mod[i] = Clear;          
}
        for(j=0; j<4; j++){ 
         if(j > 0){ 
         ref_temp_val = ref_temp_val*10;
         }
         for(i=0; i<10; i++){
         if ( ref_temp_val >= 10 ){
    	 ref_temp_val = ref_temp_val - 10;
         array_div_mod[j] ++;
         }
         } 
        }
         
return (int)(array_div_mod);                     
}



void draw_Logo(int){                              //   -------------------- Logo intro-------------
        move_cursor_xy(0,2);
        for(i=0;i<8;i++){
          dispbig_char(bck_ground_logo1[i]);
        }
        move_cursor_xy(0,4);
        for(i=8;i<16;i++){
          dispbig_char(bck_ground_logo1[i]);
        }  
        delay_extra_long(0);
        move_cursor_xy(7,2);
        for(i=16;i<24;i++){
          dispbig_char(bck_ground_logo1[i]);
        }
        move_cursor_xy(7,4);
        for(i=24;i<32;i++){
          dispbig_char(bck_ground_logo1[i]);
        }  
        delay_extra_long(0);  
        cls(0);
}



void draw_sub_menu(int){                   //   -------------------draw sub menu-------------
        cls(0);
        move_cursor_xy(12,2);
        for(i=0;i<8;i++){
          dispbig_char(bck_ground_subsolder[i]);
        }    
}